import { ref, onMounted, onBeforeUnmount } from 'vue'
import { ElMessage } from 'element-plus'

/**
 * 语音输入Todo功能
 * 支持通过语音输入创建待办事项，智能解析语音内容
 */
export function useVoiceTodo(options = {}) {
  const {
    onParseComplete = null, // 解析完成的回调
    onRecordingStart = null,
    onRecordingStop = null
  } = options

  // 语音识别相关状态
  const isVoiceSupported = ref(false)
  const isRecording = ref(false)
  const voiceTranscript = ref('') // 实时识别文本
  const recognition = ref(null)
  const accumulatedText = ref('') // 累积的识别文本

  // 初始化语音识别
  const initVoiceRecognition = () => {
    const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition

    if (!SpeechRecognition) {
      console.warn('当前浏览器不支持语音识别')
      isVoiceSupported.value = false
      return
    }

    isVoiceSupported.value = true
    recognition.value = new SpeechRecognition()

    // 配置语音识别
    recognition.value.lang = 'zh-CN' // 中文识别
    recognition.value.continuous = true // 持续监听
    recognition.value.interimResults = true // 显示临时结果
    recognition.value.maxAlternatives = 1

    // 识别结果事件
    recognition.value.onresult = (event) => {
      // 在持续模式下，需要累积所有最终结果
      // event.results包含从开始到现在的所有结果
      let fullText = ''
      let hasInterim = false
      let interimText = ''
      
      // 遍历所有结果
      for (let i = 0; i < event.results.length; i++) {
        const result = event.results[i]
        const transcript = result[0].transcript
        
        if (result.isFinal) {
          // 最终结果，添加到累积文本
          fullText += transcript
        } else {
          // 临时结果
          hasInterim = true
          interimText += transcript
        }
      }
      
      // 更新累积文本（只包含最终结果）
      accumulatedText.value = fullText
      
      // 显示文本：最终结果 + 临时结果
      if (hasInterim) {
        voiceTranscript.value = fullText + interimText
      } else {
        voiceTranscript.value = fullText
      }
    }

    // 识别开始
    recognition.value.onstart = () => {
      console.log('语音识别已开始')
      accumulatedText.value = ''
      voiceTranscript.value = ''
      if (onRecordingStart) onRecordingStart()
    }

    // 识别结束（持续模式下会自动重新启动）
    recognition.value.onend = () => {
      console.log('语音识别已结束')
      
      // 如果是用户主动停止，不重新启动
      if (!isRecording.value) {
        if (onRecordingStop) onRecordingStop()
        return
      }
      
      // 持续模式下，如果还在录音状态，自动重新启动识别
      if (isRecording.value) {
        try {
          console.log('持续监听模式：自动重新启动识别')
          recognition.value.start()
        } catch (error) {
          // 如果启动失败（可能是因为已经在运行），忽略错误
          if (error.name !== 'InvalidStateError') {
            console.error('重新启动识别失败:', error)
          }
        }
      }
    }

    // 识别错误
    recognition.value.onerror = (event) => {
      console.error('语音识别错误:', event.error)
      isRecording.value = false
      voiceTranscript.value = ''
      if (onRecordingStop) onRecordingStop()

      const errorMessages = {
        'no-speech': '未检测到语音，请重试',
        'audio-capture': '无法访问麦克风，请检查权限',
        'not-allowed': '麦克风权限被拒绝，请在浏览器设置中允许',
        'network': '网络错误，请检查网络连接',
        'aborted': '语音识别已取消'
      }

      const message = errorMessages[event.error] || '语音识别失败，请重试'

      if (event.error !== 'aborted') {
        ElMessage.error(message)
      }
    }
  }

  /**
   * 智能解析语音文本，提取todo信息
   * @param {string} text - 语音识别的文本
   * @returns {object} - 解析后的todo对象
   */
  const parseTodoFromText = (text) => {
    const todo = {
      title: '',
      description: '',
      categoryId: null,
      categoryName: '',
      priority: 'normal',
      dueDate: null,
      reminder: 'none',
      important: false
    }

    // 提取标题（去除命令词后的主要内容）
    let title = text.trim()

    // 移除常见的命令词
    const commandWords = [
      '创建待办', '添加待办', '新建待办', '添加todo', '创建todo',
      '记录待办', '记个待办', '添加任务', '新建任务', '创建任务'
    ]
    
    commandWords.forEach(cmd => {
      if (title.startsWith(cmd)) {
        title = title.replace(cmd, '').trim()
      }
    })

    // 提取分类
    const categoryKeywords = {
      '工作': ['工作', '办公', '公司', '项目', '会议', '工作相关的'],
      '生活': ['生活', '购物', '买菜', '做饭', '家务', '家庭'],
      '学习': ['学习', '读书', '阅读', '课程', '培训', '学习相关的']
    }

    for (const [categoryName, keywords] of Object.entries(categoryKeywords)) {
      if (keywords.some(keyword => title.includes(keyword))) {
        todo.categoryName = categoryName
        break
      }
    }

    // 提取优先级
    if (/紧急|urgent|高优先级|非常重要/.test(title)) {
      todo.priority = 'urgent'
      todo.important = true
    } else if (/高|high|重要|priority/.test(title)) {
      todo.priority = 'high'
    } else if (/低|low/.test(title)) {
      todo.priority = 'low'
    } else if (/重要|important|星标/.test(title)) {
      todo.important = true
    }

    // 提取日期时间
    const datePatterns = [
      { pattern: /今天(\s+)?(\d{1,2})[点:：](\d{1,2})/, handler: (match) => {
        const today = new Date()
        const hour = parseInt(match[2] || today.getHours())
        const minute = parseInt(match[3] || 0)
        today.setHours(hour, minute, 0, 0)
        return today
      }},
      { pattern: /明天(\s+)?(\d{1,2})[点:：](\d{1,2})/, handler: (match) => {
        const tomorrow = new Date()
        tomorrow.setDate(tomorrow.getDate() + 1)
        const hour = parseInt(match[2] || 9)
        const minute = parseInt(match[3] || 0)
        tomorrow.setHours(hour, minute, 0, 0)
        return tomorrow
      }},
      { pattern: /后天(\s+)?(\d{1,2})[点:：](\d{1,2})/, handler: (match) => {
        const dayAfter = new Date()
        dayAfter.setDate(dayAfter.getDate() + 2)
        const hour = parseInt(match[2] || 9)
        const minute = parseInt(match[3] || 0)
        dayAfter.setHours(hour, minute, 0, 0)
        return dayAfter
      }},
      { pattern: /今天/, handler: () => {
        const today = new Date()
        today.setHours(18, 0, 0, 0) // 默认今天18点
        return today
      }},
      { pattern: /明天/, handler: () => {
        const tomorrow = new Date()
        tomorrow.setDate(tomorrow.getDate() + 1)
        tomorrow.setHours(18, 0, 0, 0) // 默认明天18点
        return tomorrow
      }},
      { pattern: /后天/, handler: () => {
        const dayAfter = new Date()
        dayAfter.setDate(dayAfter.getDate() + 2)
        dayAfter.setHours(18, 0, 0, 0) // 默认后天18点
        return dayAfter
      }},
      { pattern: /(\d{1,2})月(\d{1,2})[日号](\s+)?(\d{1,2})?[点:：]?(\d{1,2})?/, handler: (match) => {
        const date = new Date()
        date.setMonth(parseInt(match[1]) - 1)
        date.setDate(parseInt(match[2]))
        date.setHours(parseInt(match[4] || 18), parseInt(match[5] || 0), 0, 0)
        return date
      }},
      { pattern: /(\d{4})[年-](\d{1,2})[月-](\d{1,2})[日号]?(\s+)?(\d{1,2})?[点:：]?(\d{1,2})?/, handler: (match) => {
        const date = new Date(
          parseInt(match[1]),
          parseInt(match[2]) - 1,
          parseInt(match[3]),
          parseInt(match[5] || 18),
          parseInt(match[6] || 0)
        )
        return date
      }}
    ]

    for (const { pattern, handler } of datePatterns) {
      const match = title.match(pattern)
      if (match) {
        try {
          todo.dueDate = handler(match)
          // 从标题中移除日期部分
          title = title.replace(pattern, '').trim()
          break
        } catch (error) {
          console.warn('日期解析失败:', error)
        }
      }
    }

    // 提取提醒
    if (/提醒|提醒我/.test(title)) {
      todo.reminder = '30' // 默认提前30分钟
    }

    // 提取描述（在"关于"、"描述"、"备注"等关键词之后的内容）
    const descPatterns = [
      /关于(.+)/,
      /描述(.+)/,
      /备注(.+)/,
      /说明(.+)/,
      /详情(.+)/
    ]

    for (const pattern of descPatterns) {
      const match = title.match(pattern)
      if (match) {
        todo.description = match[1].trim()
        title = title.replace(pattern, '').trim()
        break
      }
    }

    // 清理标题中的多余空格和标点
    title = title
      .replace(/[，,。.！!？?；;：:]/g, ' ')
      .replace(/\s+/g, ' ')
      .trim()

    todo.title = title || '新待办事项'

    return todo
  }

  /**
   * 处理解析完成的语音文本
   */
  const handleParseTranscript = (transcript) => {
    if (!transcript.trim()) return

    const parsedTodo = parseTodoFromText(transcript)
    
    if (onParseComplete) {
      onParseComplete(parsedTodo, transcript)
    }
  }

  /**
   * 开始语音录制
   */
  const startRecording = () => {
    if (!recognition.value) {
      ElMessage.warning('语音识别未初始化')
      return
    }

    if (isRecording.value) {
      ElMessage.warning('正在录制中，请稍候')
      return
    }

    try {
      isRecording.value = true
      voiceTranscript.value = ''
      accumulatedText.value = ''
      recognition.value.start()
    } catch (error) {
      console.error('语音识别启动失败:', error)
      ElMessage.error('语音识别启动失败，请稍后重试')
      isRecording.value = false
    }
  }

  /**
   * 停止语音录制
   */
  const stopRecording = () => {
    if (recognition.value && isRecording.value) {
      // 先停止识别
      isRecording.value = false
      
      // 停止识别服务
      try {
        recognition.value.stop()
      } catch (error) {
        console.warn('停止识别时出错:', error)
      }
      
      // 如果有识别文本，处理解析
      const finalText = voiceTranscript.value.trim()
      if (finalText) {
        handleParseTranscript(finalText)
      }
      
      // 清空文本
      voiceTranscript.value = ''
      accumulatedText.value = ''
      
      if (onRecordingStop) onRecordingStop()
    }
  }

  /**
   * 切换录制状态
   */
  const toggleRecording = () => {
    if (!isVoiceSupported.value) {
      ElMessage.warning('您的浏览器不支持语音识别，请使用Chrome或Edge浏览器')
      return
    }

    if (isRecording.value) {
      stopRecording()
    } else {
      startRecording()
    }
  }

  /**
   * 清除已识别的文本（重置功能）
   * 不清除录音状态，继续录音
   */
  const clearTranscript = () => {
    voiceTranscript.value = ''
    accumulatedText.value = ''
    // 如果识别服务正在运行，需要重新开始以清除历史结果
    if (recognition.value && isRecording.value) {
      try {
        // 停止当前识别
        recognition.value.stop()
        // 等待停止后重新开始，这样可以清除累积的结果
        setTimeout(() => {
          if (isRecording.value) {
            recognition.value.start()
          }
        }, 100)
      } catch (error) {
        console.warn('重置文本时出错:', error)
        // 即使出错也清空显示文本
      }
    }
  }

  // 组件挂载时初始化
  onMounted(() => {
    initVoiceRecognition()
  })

  // 组件卸载时清理
  onBeforeUnmount(() => {
    if (recognition.value && isRecording.value) {
      recognition.value.stop()
    }
  })

  return {
    isVoiceSupported,
    isRecording,
    voiceTranscript,
    startRecording,
    stopRecording,
    toggleRecording,
    clearTranscript, // 清除文本功能
    parseTodoFromText // 暴露解析函数，方便外部使用
  }
}

